home *** CD-ROM | disk | FTP | other *** search
/ Erotic Games: Memory / Erotic Games: Memory.iso / mac / air_installers / AdobeAIR.exe / setup.swf / scripts / mx / controls / List.as < prev    next >
Text File  |  2009-02-12  |  64KB  |  1,819 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.events.FocusEvent;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.geom.Point;
  12.    import flash.ui.Keyboard;
  13.    import flash.utils.Dictionary;
  14.    import mx.collections.CursorBookmark;
  15.    import mx.collections.IList;
  16.    import mx.collections.ItemResponder;
  17.    import mx.collections.ItemWrapper;
  18.    import mx.collections.ModifiedCollectionView;
  19.    import mx.collections.errors.ItemPendingError;
  20.    import mx.controls.listClasses.BaseListData;
  21.    import mx.controls.listClasses.IDropInListItemRenderer;
  22.    import mx.controls.listClasses.IListItemRenderer;
  23.    import mx.controls.listClasses.ListBase;
  24.    import mx.controls.listClasses.ListBaseSeekPending;
  25.    import mx.controls.listClasses.ListData;
  26.    import mx.controls.listClasses.ListItemRenderer;
  27.    import mx.controls.listClasses.ListRowInfo;
  28.    import mx.controls.scrollClasses.ScrollBar;
  29.    import mx.core.ClassFactory;
  30.    import mx.core.EdgeMetrics;
  31.    import mx.core.EventPriority;
  32.    import mx.core.FlexShape;
  33.    import mx.core.FlexSprite;
  34.    import mx.core.FlexVersion;
  35.    import mx.core.IFactory;
  36.    import mx.core.IIMESupport;
  37.    import mx.core.IInvalidating;
  38.    import mx.core.IPropertyChangeNotifier;
  39.    import mx.core.ScrollPolicy;
  40.    import mx.core.UIComponent;
  41.    import mx.core.UIComponentGlobals;
  42.    import mx.core.mx_internal;
  43.    import mx.events.CollectionEvent;
  44.    import mx.events.CollectionEventKind;
  45.    import mx.events.ListEvent;
  46.    import mx.events.ListEventReason;
  47.    import mx.events.ScrollEvent;
  48.    import mx.events.ScrollEventDetail;
  49.    import mx.managers.IFocusManager;
  50.    import mx.managers.IFocusManagerComponent;
  51.    import mx.styles.StyleManager;
  52.    
  53.    use namespace mx_internal;
  54.    
  55.    public class List extends ListBase implements IIMESupport
  56.    {
  57.       
  58.       mx_internal static const VERSION:String = "3.0.0.0";
  59.       
  60.       mx_internal static var createAccessibilityImplementation:Function;
  61.        
  62.       
  63.       public var editorXOffset:Number = 0;
  64.       
  65.       public var itemEditorInstance:IListItemRenderer;
  66.       
  67.       public var rendererIsEditor:Boolean = false;
  68.       
  69.       private var dontEdit:Boolean = false;
  70.       
  71.       public var editorYOffset:Number = 0;
  72.       
  73.       public var editorWidthOffset:Number = 0;
  74.       
  75.       private var lastEditedItemPosition;
  76.       
  77.       public var itemEditor:IFactory;
  78.       
  79.       public var editable:Boolean = false;
  80.       
  81.       private var losingFocus:Boolean = false;
  82.       
  83.       public var editorUsesEnterKey:Boolean = false;
  84.       
  85.       public var editorDataField:String = "text";
  86.       
  87.       private var bEditedItemPositionChanged:Boolean = false;
  88.       
  89.       mx_internal var _lockedRowCount:int = 0;
  90.       
  91.       private var inEndEdit:Boolean = false;
  92.       
  93.       public var editorHeightOffset:Number = 0;
  94.       
  95.       private var _editedItemPosition:Object;
  96.       
  97.       private var _imeMode:String;
  98.       
  99.       private var actualRowIndex:int;
  100.       
  101.       private var _proposedEditedItemPosition;
  102.       
  103.       private var actualColIndex:int = 0;
  104.       
  105.       protected var measuringObjects:Dictionary;
  106.       
  107.       public function List()
  108.       {
  109.          itemEditor = new ClassFactory(TextInput);
  110.          super();
  111.          listType = "vertical";
  112.          bColumnScrolling = false;
  113.          itemRenderer = new ClassFactory(ListItemRenderer);
  114.          _horizontalScrollPolicy = ScrollPolicy.OFF;
  115.          _verticalScrollPolicy = ScrollPolicy.AUTO;
  116.          defaultColumnCount = 1;
  117.          defaultRowCount = 7;
  118.          addEventListener(ListEvent.ITEM_EDIT_BEGINNING,itemEditorItemEditBeginningHandler,false,EventPriority.DEFAULT_HANDLER);
  119.          addEventListener(ListEvent.ITEM_EDIT_BEGIN,itemEditorItemEditBeginHandler,false,EventPriority.DEFAULT_HANDLER);
  120.          addEventListener(ListEvent.ITEM_EDIT_END,itemEditorItemEditEndHandler,false,EventPriority.DEFAULT_HANDLER);
  121.       }
  122.       
  123.       override public function measureWidthOfItems(param1:int = -1, param2:int = 0) : Number
  124.       {
  125.          var item:IListItemRenderer = null;
  126.          var rw:Number = NaN;
  127.          var data:Object = null;
  128.          var factory:IFactory = null;
  129.          var index:int = param1;
  130.          var count:int = param2;
  131.          if(count == 0)
  132.          {
  133.             count = !!collection ? int(collection.length) : 0;
  134.          }
  135.          if(collection && collection.length == 0)
  136.          {
  137.             count = 0;
  138.          }
  139.          var w:Number = 0;
  140.          var bookmark:CursorBookmark = !!iterator ? iterator.bookmark : null;
  141.          if(index != -1 && iterator)
  142.          {
  143.             try
  144.             {
  145.                iterator.seek(CursorBookmark.FIRST,index);
  146.             }
  147.             catch(e:ItemPendingError)
  148.             {
  149.                return 0;
  150.             }
  151.          }
  152.          var more:Boolean = iterator != null;
  153.          var i:int = 0;
  154.          while(i < count)
  155.          {
  156.             if(more)
  157.             {
  158.                data = iterator.current;
  159.                factory = getItemRendererFactory(data);
  160.                item = measuringObjects[factory];
  161.                if(!item)
  162.                {
  163.                   item = getMeasuringRenderer(data);
  164.                }
  165.                item.explicitWidth = NaN;
  166.                setupRendererFromData(item,data);
  167.                rw = item.measuredWidth;
  168.                w = Math.max(w,rw);
  169.             }
  170.             if(more)
  171.             {
  172.                try
  173.                {
  174.                   more = iterator.moveNext();
  175.                }
  176.                catch(e:ItemPendingError)
  177.                {
  178.                   more = false;
  179.                }
  180.             }
  181.             i++;
  182.          }
  183.          if(iterator)
  184.          {
  185.             iterator.seek(bookmark,0);
  186.          }
  187.          if(w == 0)
  188.          {
  189.             if(explicitWidth)
  190.             {
  191.                return explicitWidth;
  192.             }
  193.             return DEFAULT_MEASURED_WIDTH;
  194.          }
  195.          var paddingLeft:Number = getStyle("paddingLeft");
  196.          var paddingRight:Number = getStyle("paddingRight");
  197.          w += paddingLeft + paddingRight;
  198.          return w;
  199.       }
  200.       
  201.       private function findNextEnterItemRenderer(param1:KeyboardEvent) : void
  202.       {
  203.          if(_proposedEditedItemPosition !== undefined)
  204.          {
  205.             return;
  206.          }
  207.          _editedItemPosition = lastEditedItemPosition;
  208.          var _loc2_:int = _editedItemPosition.rowIndex;
  209.          var _loc3_:int = _editedItemPosition.columnIndex;
  210.          var _loc4_:int;
  211.          if((_loc4_ = _editedItemPosition.rowIndex + (!!param1.shiftKey ? -1 : 1)) < collection.length && _loc4_ >= 0)
  212.          {
  213.             _loc2_ = _loc4_;
  214.          }
  215.          var _loc5_:ListEvent;
  216.          (_loc5_ = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true)).rowIndex = _loc2_;
  217.          _loc5_.columnIndex = 0;
  218.          dispatchEvent(_loc5_);
  219.       }
  220.       
  221.       public function get imeMode() : String
  222.       {
  223.          return _imeMode;
  224.       }
  225.       
  226.       private function mouseFocusChangeHandler(param1:MouseEvent) : void
  227.       {
  228.          if(itemEditorInstance && !param1.isDefaultPrevented() && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  229.          {
  230.             param1.preventDefault();
  231.          }
  232.       }
  233.       
  234.       public function set imeMode(param1:String) : void
  235.       {
  236.          _imeMode = param1;
  237.       }
  238.       
  239.       override protected function mouseUpHandler(param1:MouseEvent) : void
  240.       {
  241.          var _loc2_:ListEvent = null;
  242.          var _loc3_:IListItemRenderer = null;
  243.          var _loc4_:Sprite = null;
  244.          var _loc5_:int = 0;
  245.          var _loc6_:int = 0;
  246.          var _loc7_:Point = null;
  247.          _loc3_ = mouseEventToItemRenderer(param1);
  248.          super.mouseUpHandler(param1);
  249.          if(_loc3_ && _loc3_.data && _loc3_ != itemEditorInstance)
  250.          {
  251.             _loc7_ = itemRendererToIndices(_loc3_);
  252.             if(editable && !dontEdit)
  253.             {
  254.                _loc2_ = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  255.                _loc2_.rowIndex = _loc7_.y;
  256.                _loc2_.columnIndex = 0;
  257.                _loc2_.itemRenderer = _loc3_;
  258.                dispatchEvent(_loc2_);
  259.             }
  260.          }
  261.       }
  262.       
  263.       private function itemEditorItemEditEndHandler(param1:ListEvent) : void
  264.       {
  265.          var bChanged:Boolean = false;
  266.          var bFieldChanged:Boolean = false;
  267.          var newData:Object = null;
  268.          var data:Object = null;
  269.          var editCollection:IList = null;
  270.          var listData:BaseListData = null;
  271.          var fm:IFocusManager = null;
  272.          var event:ListEvent = param1;
  273.          if(!event.isDefaultPrevented())
  274.          {
  275.             bChanged = false;
  276.             bFieldChanged = false;
  277.             newData = itemEditorInstance[editorDataField];
  278.             data = event.itemRenderer.data;
  279.             if(data is String)
  280.             {
  281.                if(!(newData is String))
  282.                {
  283.                   newData = newData.toString();
  284.                }
  285.             }
  286.             else if(data is uint)
  287.             {
  288.                if(!(newData is uint))
  289.                {
  290.                   newData = uint(newData);
  291.                }
  292.             }
  293.             else if(data is int)
  294.             {
  295.                if(!(newData is int))
  296.                {
  297.                   newData = int(newData);
  298.                }
  299.             }
  300.             else if(data is Number)
  301.             {
  302.                if(!(newData is int))
  303.                {
  304.                   newData = Number(newData);
  305.                }
  306.             }
  307.             else
  308.             {
  309.                bFieldChanged = true;
  310.                try
  311.                {
  312.                   data[labelField] = newData;
  313.                   if(!(data is IPropertyChangeNotifier))
  314.                   {
  315.                      if(actualCollection)
  316.                      {
  317.                         actualCollection.itemUpdated(data,labelField);
  318.                      }
  319.                      else
  320.                      {
  321.                         collection.itemUpdated(data,labelField);
  322.                      }
  323.                   }
  324.                }
  325.                catch(e:Error)
  326.                {
  327.                   trace("attempt to write to",labelField,"failed.  You may need a custom ITEM_EDIT_END handler");
  328.                }
  329.             }
  330.             if(!bFieldChanged)
  331.             {
  332.                if(data !== newData)
  333.                {
  334.                   bChanged = true;
  335.                   data = newData;
  336.                }
  337.                if(bChanged)
  338.                {
  339.                   editCollection = !!actualCollection ? actualCollection as IList : collection as IList;
  340.                   if(editCollection)
  341.                   {
  342.                      IList(editCollection).setItemAt(data,event.rowIndex);
  343.                   }
  344.                   else
  345.                   {
  346.                      trace("attempt to update collection failed.  You may need a custom ITEM_EDIT_END handler");
  347.                   }
  348.                }
  349.             }
  350.             if(event.itemRenderer is IDropInListItemRenderer)
  351.             {
  352.                listData = BaseListData(IDropInListItemRenderer(event.itemRenderer).listData);
  353.                listData.label = itemToLabel(data);
  354.                IDropInListItemRenderer(event.itemRenderer).listData = listData;
  355.             }
  356.             delete visibleData[itemToUID(event.itemRenderer.data)];
  357.             event.itemRenderer.data = data;
  358.             visibleData[itemToUID(data)] = event.itemRenderer;
  359.          }
  360.          else if(event.reason != ListEventReason.OTHER)
  361.          {
  362.             if(itemEditorInstance && _editedItemPosition)
  363.             {
  364.                if(selectedIndex != _editedItemPosition.rowIndex)
  365.                {
  366.                   selectedIndex = _editedItemPosition.rowIndex;
  367.                }
  368.                fm = focusManager;
  369.                if(itemEditorInstance is IFocusManagerComponent)
  370.                {
  371.                   fm.setFocus(IFocusManagerComponent(itemEditorInstance));
  372.                }
  373.             }
  374.          }
  375.          if(event.reason == ListEventReason.OTHER || !event.isDefaultPrevented())
  376.          {
  377.             destroyItemEditor();
  378.          }
  379.       }
  380.       
  381.       private function itemEditorItemEditBeginningHandler(param1:ListEvent) : void
  382.       {
  383.          if(!param1.isDefaultPrevented())
  384.          {
  385.             setEditedItemPosition({
  386.                "columnIndex":param1.columnIndex,
  387.                "rowIndex":param1.rowIndex
  388.             });
  389.          }
  390.          else if(!itemEditorInstance)
  391.          {
  392.             _editedItemPosition = null;
  393.             editable = false;
  394.             setFocus();
  395.             editable = true;
  396.          }
  397.       }
  398.       
  399.       override public function createItemRenderer(param1:Object) : IListItemRenderer
  400.       {
  401.          var _loc2_:IFactory = null;
  402.          var _loc3_:IListItemRenderer = null;
  403.          var _loc4_:Dictionary = null;
  404.          var _loc5_:* = undefined;
  405.          _loc2_ = getItemRendererFactory(param1);
  406.          if(!_loc2_)
  407.          {
  408.             if(param1 == null)
  409.             {
  410.                _loc2_ = nullItemRenderer;
  411.             }
  412.             if(!_loc2_)
  413.             {
  414.                _loc2_ = itemRenderer;
  415.             }
  416.          }
  417.          if(_loc2_ == itemRenderer)
  418.          {
  419.             if(freeItemRenderers && freeItemRenderers.length)
  420.             {
  421.                _loc3_ = freeItemRenderers.pop();
  422.                delete freeItemRenderersByFactory[_loc2_][_loc3_];
  423.             }
  424.          }
  425.          else if(freeItemRenderersByFactory)
  426.          {
  427.             if(_loc4_ = freeItemRenderersByFactory[_loc2_])
  428.             {
  429.                var _loc6_:int = 0;
  430.                var _loc7_:* = _loc4_;
  431.                for(_loc5_ in _loc7_)
  432.                {
  433.                   _loc3_ = IListItemRenderer(_loc5_);
  434.                   delete _loc4_[_loc5_];
  435.                }
  436.             }
  437.          }
  438.          if(!_loc3_)
  439.          {
  440.             _loc3_ = _loc2_.newInstance();
  441.             _loc3_.styleName = this;
  442.             factoryMap[_loc3_] = _loc2_;
  443.          }
  444.          _loc3_.owner = this;
  445.          return _loc3_;
  446.       }
  447.       
  448.       override protected function focusOutHandler(param1:FocusEvent) : void
  449.       {
  450.          if(param1.target == this)
  451.          {
  452.             super.focusOutHandler(param1);
  453.          }
  454.          if(param1.relatedObject == this && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  455.          {
  456.             return;
  457.          }
  458.          if(param1.relatedObject == null && itemRendererContains(editedItemRenderer,DisplayObject(param1.target)))
  459.          {
  460.             return;
  461.          }
  462.          if(param1.relatedObject == null && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  463.          {
  464.             return;
  465.          }
  466.          if(itemEditorInstance && (!param1.relatedObject || !itemRendererContains(itemEditorInstance,param1.relatedObject)))
  467.          {
  468.             endEdit(ListEventReason.OTHER);
  469.             removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  470.             removeEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  471.          }
  472.       }
  473.       
  474.       override protected function scrollHorizontally(param1:int, param2:int, param3:Boolean) : void
  475.       {
  476.          var _loc4_:int = listItems.length;
  477.          var _loc5_:Number = getStyle("paddingLeft");
  478.          var _loc6_:int = 0;
  479.          while(_loc6_ < _loc4_)
  480.          {
  481.             if(listItems[_loc6_].length)
  482.             {
  483.                listItems[_loc6_][0].x = -param1 + _loc5_;
  484.             }
  485.             _loc6_++;
  486.          }
  487.       }
  488.       
  489.       override protected function drawHighlightIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  490.       {
  491.          super.drawHighlightIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  492.       }
  493.       
  494.       [Bindable("itemFocusIn")]
  495.       public function get editedItemPosition() : Object
  496.       {
  497.          if(_editedItemPosition)
  498.          {
  499.             return {
  500.                "rowIndex":_editedItemPosition.rowIndex,
  501.                "columnIndex":0
  502.             };
  503.          }
  504.          return _editedItemPosition;
  505.       }
  506.       
  507.       private function setEditedItemPosition(param1:Object) : void
  508.       {
  509.          bEditedItemPositionChanged = true;
  510.          _proposedEditedItemPosition = param1;
  511.          invalidateDisplayList();
  512.       }
  513.       
  514.       override protected function drawRowBackgrounds() : void
  515.       {
  516.          var _loc2_:Array = null;
  517.          var _loc6_:int = 0;
  518.          var _loc1_:Sprite = Sprite(listContent.getChildByName("rowBGs"));
  519.          if(!_loc1_)
  520.          {
  521.             _loc1_ = new FlexSprite();
  522.             _loc1_.mouseEnabled = false;
  523.             _loc1_.name = "rowBGs";
  524.             listContent.addChildAt(_loc1_,0);
  525.          }
  526.          _loc2_ = getStyle("alternatingItemColors");
  527.          if(!_loc2_ || _loc2_.length == 0)
  528.          {
  529.             while(_loc1_.numChildren > _loc6_)
  530.             {
  531.                _loc1_.removeChildAt(_loc1_.numChildren - 1);
  532.             }
  533.             return;
  534.          }
  535.          StyleManager.getColorNames(_loc2_);
  536.          var _loc3_:int = 0;
  537.          var _loc4_:int = verticalScrollPosition;
  538.          var _loc5_:int = 0;
  539.          _loc6_ = listItems.length;
  540.          while(_loc3_ < _loc6_)
  541.          {
  542.             drawRowBackground(_loc1_,_loc5_++,rowInfo[_loc3_].y,rowInfo[_loc3_].height,_loc2_[_loc4_ % _loc2_.length],_loc4_);
  543.             _loc3_++;
  544.             _loc4_++;
  545.          }
  546.          while(_loc1_.numChildren > _loc6_)
  547.          {
  548.             _loc1_.removeChildAt(_loc1_.numChildren - 1);
  549.          }
  550.       }
  551.       
  552.       override protected function drawCaretIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  553.       {
  554.          super.drawCaretIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  555.       }
  556.       
  557.       private function deactivateHandler(param1:Event) : void
  558.       {
  559.          if(itemEditorInstance)
  560.          {
  561.             endEdit(ListEventReason.OTHER);
  562.             losingFocus = true;
  563.             setFocus();
  564.          }
  565.       }
  566.       
  567.       protected function layoutEditor(param1:int, param2:int, param3:int, param4:int) : void
  568.       {
  569.          itemEditorInstance.move(param1,param2);
  570.          itemEditorInstance.setActualSize(param3,param4);
  571.       }
  572.       
  573.       private function editorKeyDownHandler(param1:KeyboardEvent) : void
  574.       {
  575.          if(param1.keyCode == Keyboard.ESCAPE)
  576.          {
  577.             endEdit(ListEventReason.CANCELLED);
  578.          }
  579.          else if(param1.ctrlKey && param1.charCode == 46)
  580.          {
  581.             endEdit(ListEventReason.CANCELLED);
  582.          }
  583.          else if(param1.charCode == Keyboard.ENTER && param1.keyCode != 229)
  584.          {
  585.             if(editorUsesEnterKey)
  586.             {
  587.                return;
  588.             }
  589.             if(endEdit(ListEventReason.NEW_ROW))
  590.             {
  591.                if(!dontEdit)
  592.                {
  593.                   findNextEnterItemRenderer(param1);
  594.                }
  595.             }
  596.          }
  597.       }
  598.       
  599.       private function itemEditorItemEditBeginHandler(param1:ListEvent) : void
  600.       {
  601.          var _loc2_:IFocusManager = null;
  602.          stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  603.          if(!param1.isDefaultPrevented() && listItems[actualRowIndex][actualColIndex].data != null)
  604.          {
  605.             createItemEditor(param1.columnIndex,param1.rowIndex);
  606.             if(editedItemRenderer is IDropInListItemRenderer && itemEditorInstance is IDropInListItemRenderer)
  607.             {
  608.                IDropInListItemRenderer(itemEditorInstance).listData = IDropInListItemRenderer(editedItemRenderer).listData;
  609.             }
  610.             if(!rendererIsEditor)
  611.             {
  612.                itemEditorInstance.data = editedItemRenderer.data;
  613.             }
  614.             if(itemEditorInstance is IInvalidating)
  615.             {
  616.                IInvalidating(itemEditorInstance).validateNow();
  617.             }
  618.             if(itemEditorInstance is IIMESupport)
  619.             {
  620.                IIMESupport(itemEditorInstance).imeMode = imeMode;
  621.             }
  622.             _loc2_ = focusManager;
  623.             if(itemEditorInstance is IFocusManagerComponent)
  624.             {
  625.                _loc2_.setFocus(IFocusManagerComponent(itemEditorInstance));
  626.             }
  627.             _loc2_.defaultButtonEnabled = false;
  628.             param1 = new ListEvent(ListEvent.ITEM_FOCUS_IN);
  629.             param1.rowIndex = _editedItemPosition.rowIndex;
  630.             param1.itemRenderer = itemEditorInstance;
  631.             dispatchEvent(param1);
  632.          }
  633.       }
  634.       
  635.       private function editingTemporarilyPrevented(param1:Object) : Boolean
  636.       {
  637.          var _loc2_:int = 0;
  638.          var _loc3_:IListItemRenderer = null;
  639.          if(runningDataEffect && param1)
  640.          {
  641.             _loc2_ = param1.rowIndex - verticalScrollPosition + offscreenExtraRowsTop;
  642.             if(_loc2_ < 0 || _loc2_ >= listItems.length)
  643.             {
  644.                return false;
  645.             }
  646.             _loc3_ = listItems[_loc2_][0];
  647.             if(_loc3_ && (getRendererSemanticValue(_loc3_,"replaced") || getRendererSemanticValue(_loc3_,"removed")))
  648.             {
  649.                return true;
  650.             }
  651.          }
  652.          return false;
  653.       }
  654.       
  655.       override public function measureHeightOfItems(param1:int = -1, param2:int = 0) : Number
  656.       {
  657.          var data:Object = null;
  658.          var item:IListItemRenderer = null;
  659.          var index:int = param1;
  660.          var count:int = param2;
  661.          if(count == 0)
  662.          {
  663.             count = !!collection ? int(collection.length) : 0;
  664.          }
  665.          var paddingTop:Number = getStyle("paddingTop");
  666.          var paddingBottom:Number = getStyle("paddingBottom");
  667.          var ww:Number = 200;
  668.          if(listContent.width)
  669.          {
  670.             ww = listContent.width;
  671.          }
  672.          var h:Number = 0;
  673.          var bookmark:CursorBookmark = !!iterator ? iterator.bookmark : null;
  674.          if(index != -1 && iterator)
  675.          {
  676.             iterator.seek(CursorBookmark.FIRST,index);
  677.          }
  678.          var rh:Number = rowHeight;
  679.          var more:Boolean = iterator != null;
  680.          var i:int = 0;
  681.          while(i < count)
  682.          {
  683.             if(more)
  684.             {
  685.                rh = rowHeight;
  686.                data = iterator.current;
  687.                item = getMeasuringRenderer(data);
  688.                item.explicitWidth = ww;
  689.                setupRendererFromData(item,data);
  690.                if(variableRowHeight)
  691.                {
  692.                   rh = item.getExplicitOrMeasuredHeight() + paddingTop + paddingBottom;
  693.                }
  694.             }
  695.             h += rh;
  696.             if(more)
  697.             {
  698.                try
  699.                {
  700.                   more = iterator.moveNext();
  701.                }
  702.                catch(e:ItemPendingError)
  703.                {
  704.                   more = false;
  705.                }
  706.             }
  707.             i++;
  708.          }
  709.          if(iterator)
  710.          {
  711.             iterator.seek(bookmark,0);
  712.          }
  713.          return h;
  714.       }
  715.       
  716.       mx_internal function callSetupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  717.       {
  718.          setupRendererFromData(param1,param2);
  719.       }
  720.       
  721.       override protected function drawSelectionIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  722.       {
  723.          super.drawSelectionIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  724.       }
  725.       
  726.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  727.       {
  728.          if(param1.keyCode == Keyboard.TAB && !param1.isDefaultPrevented() && findNextItemRenderer(param1.shiftKey))
  729.          {
  730.             param1.preventDefault();
  731.          }
  732.       }
  733.       
  734.       public function set editedItemPosition(param1:Object) : void
  735.       {
  736.          var _loc2_:Object = {
  737.             "rowIndex":param1.rowIndex,
  738.             "columnIndex":0
  739.          };
  740.          setEditedItemPosition(_loc2_);
  741.       }
  742.       
  743.       override protected function makeRowsAndColumns(param1:Number, param2:Number, param3:Number, param4:Number, param5:int, param6:int, param7:Boolean = false, param8:uint = 0) : Point
  744.       {
  745.          var yy:Number = NaN;
  746.          var hh:Number = NaN;
  747.          var i:int = 0;
  748.          var j:int = 0;
  749.          var item:IListItemRenderer = null;
  750.          var oldItem:IListItemRenderer = null;
  751.          var rowData:BaseListData = null;
  752.          var data:Object = null;
  753.          var wrappedData:Object = null;
  754.          var uid:String = null;
  755.          var rh:Number = NaN;
  756.          var ld:BaseListData = null;
  757.          var rr:Array = null;
  758.          var rowInfo:ListRowInfo = null;
  759.          var dx:Number = NaN;
  760.          var dy:Number = NaN;
  761.          var dw:Number = NaN;
  762.          var dh:Number = NaN;
  763.          var left:Number = param1;
  764.          var top:Number = param2;
  765.          var right:Number = param3;
  766.          var bottom:Number = param4;
  767.          var firstCol:int = param5;
  768.          var firstRow:int = param6;
  769.          var byCount:Boolean = param7;
  770.          var rowsNeeded:uint = param8;
  771.          listContent.allowItemSizeChangeNotification = false;
  772.          var paddingLeft:Number = getStyle("paddingLeft");
  773.          var paddingRight:Number = getStyle("paddingRight");
  774.          var xx:Number = left + paddingLeft - horizontalScrollPosition;
  775.          var ww:Number = right - paddingLeft - paddingRight;
  776.          var bSelected:Boolean = false;
  777.          var bHighlight:Boolean = false;
  778.          var bCaret:Boolean = false;
  779.          var colNum:int = 0;
  780.          var rowNum:int = lockedRowCount;
  781.          var rowsMade:int = 0;
  782.          var more:Boolean = true;
  783.          var valid:Boolean = true;
  784.          yy = top;
  785.          rowNum = firstRow;
  786.          more = iterator != null && !iterator.afterLast && iteratorValid;
  787.          while(!byCount && yy < bottom || byCount && rowsNeeded > 0)
  788.          {
  789.             if(byCount)
  790.             {
  791.                rowsNeeded--;
  792.             }
  793.             valid = more;
  794.             wrappedData = !!more ? iterator.current : null;
  795.             data = wrappedData is ItemWrapper ? wrappedData.data : wrappedData;
  796.             uid = null;
  797.             if(!listItems[rowNum])
  798.             {
  799.                listItems[rowNum] = [];
  800.             }
  801.             if(valid)
  802.             {
  803.                item = listItems[rowNum][colNum];
  804.                uid = itemToUID(wrappedData);
  805.                if(!item || (runningDataEffect && dataItemWrappersByRenderer[item] ? Boolean(dataItemWrappersByRenderer[item] != wrappedData) : Boolean(item.data != data)))
  806.                {
  807.                   if(mx_internal::allowRendererStealingDuringLayout)
  808.                   {
  809.                      item = visibleData[uid];
  810.                      if(!item && wrappedData != data)
  811.                      {
  812.                         item = visibleData[itemToUID(data)];
  813.                      }
  814.                   }
  815.                   if(item)
  816.                   {
  817.                      ld = BaseListData(rowMap[item.name]);
  818.                      if(ld && ld.rowIndex > rowNum)
  819.                      {
  820.                         listItems[ld.rowIndex] = [];
  821.                      }
  822.                      else
  823.                      {
  824.                         item = null;
  825.                      }
  826.                   }
  827.                   if(!item)
  828.                   {
  829.                      item = getReservedOrFreeItemRenderer(wrappedData);
  830.                   }
  831.                   if(!item)
  832.                   {
  833.                      item = createItemRenderer(data);
  834.                      item.owner = this;
  835.                      item.styleName = listContent;
  836.                      listContent.addChild(DisplayObject(item));
  837.                   }
  838.                   oldItem = listItems[rowNum][colNum];
  839.                   if(oldItem)
  840.                   {
  841.                      addToFreeItemRenderers(oldItem);
  842.                   }
  843.                   listItems[rowNum][colNum] = item;
  844.                }
  845.                rowData = makeListData(data,uid,rowNum);
  846.                rowMap[item.name] = rowData;
  847.                if(item is IDropInListItemRenderer)
  848.                {
  849.                   if(data != null)
  850.                   {
  851.                      IDropInListItemRenderer(item).listData = rowData;
  852.                   }
  853.                   else
  854.                   {
  855.                      IDropInListItemRenderer(item).listData = null;
  856.                   }
  857.                }
  858.                item.data = data;
  859.                item.enabled = enabled;
  860.                item.visible = true;
  861.                if(uid != null)
  862.                {
  863.                   visibleData[uid] = item;
  864.                }
  865.                if(wrappedData != data)
  866.                {
  867.                   dataItemWrappersByRenderer[item] = wrappedData;
  868.                }
  869.                item.explicitWidth = ww;
  870.                if(item is IInvalidating && (wordWrapChanged || variableRowHeight))
  871.                {
  872.                   IInvalidating(item).invalidateSize();
  873.                }
  874.                UIComponentGlobals.layoutManager.validateClient(item,true);
  875.                hh = Math.ceil(!!variableRowHeight ? Number(item.getExplicitOrMeasuredHeight() + mx_internal::cachedPaddingTop + mx_internal::cachedPaddingBottom) : Number(rowHeight));
  876.                rh = item.getExplicitOrMeasuredHeight();
  877.                item.setActualSize(ww,!!variableRowHeight ? Number(rh) : Number(rowHeight - mx_internal::cachedPaddingTop - mx_internal::cachedPaddingBottom));
  878.                item.move(xx,yy + mx_internal::cachedPaddingTop);
  879.             }
  880.             else
  881.             {
  882.                hh = rowNum > 0 ? Number(rowInfo[rowNum - 1].height) : Number(rowHeight);
  883.                if(hh == 0)
  884.                {
  885.                   hh = rowHeight;
  886.                }
  887.                oldItem = listItems[rowNum][colNum];
  888.                if(oldItem)
  889.                {
  890.                   addToFreeItemRenderers(oldItem);
  891.                   listItems[rowNum].splice(colNum,1);
  892.                }
  893.             }
  894.             bSelected = selectedData[uid] != null;
  895.             if(wrappedData != data)
  896.             {
  897.                bSelected = bSelected || selectedData[itemToUID(data)];
  898.                bSelected = bSelected && !getRendererSemanticValue(item,ModifiedCollectionView.REPLACEMENT) && !getRendererSemanticValue(item,ModifiedCollectionView.ADDED);
  899.             }
  900.             bHighlight = highlightUID == uid;
  901.             bCaret = caretUID == uid;
  902.             rowInfo[rowNum] = new ListRowInfo(yy,hh,uid,data);
  903.             if(valid)
  904.             {
  905.                drawItem(item,bSelected,bHighlight,bCaret);
  906.             }
  907.             yy += hh;
  908.             rowNum++;
  909.             rowsMade++;
  910.             if(iterator && more)
  911.             {
  912.                try
  913.                {
  914.                   more = iterator.moveNext();
  915.                }
  916.                catch(e:ItemPendingError)
  917.                {
  918.                   lastSeekPending = new ListBaseSeekPending(CursorBookmark.CURRENT,0);
  919.                   e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  920.                   more = false;
  921.                   iteratorValid = false;
  922.                }
  923.             }
  924.          }
  925.          if(!byCount)
  926.          {
  927.             while(rowNum < listItems.length)
  928.             {
  929.                rr = listItems.pop();
  930.                rowInfo.pop();
  931.                while(rr.length)
  932.                {
  933.                   item = rr.pop();
  934.                   addToFreeItemRenderers(item);
  935.                }
  936.             }
  937.          }
  938.          if(itemEditorInstance)
  939.          {
  940.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  941.             item = listItems[actualRowIndex][actualColIndex];
  942.             rowInfo = rowInfo[actualRowIndex];
  943.             if(item && !rendererIsEditor)
  944.             {
  945.                dx = editorXOffset;
  946.                dy = editorYOffset;
  947.                dw = editorWidthOffset;
  948.                dh = editorHeightOffset;
  949.                layoutEditor(item.x + dx,rowInfo.y + dy,Math.min(item.width + dw,listContent.width - listContent.x - itemEditorInstance.x),Math.min(rowInfo.height + dh,listContent.height - listContent.y - itemEditorInstance.y));
  950.             }
  951.          }
  952.          listContent.allowItemSizeChangeNotification = variableRowHeight;
  953.          return new Point(colNum,rowsMade);
  954.       }
  955.       
  956.       override protected function measure() : void
  957.       {
  958.          super.measure();
  959.          var _loc1_:EdgeMetrics = viewMetrics;
  960.          measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
  961.          if(initialized && variableRowHeight && explicitRowCount < 1 && isNaN(explicitRowHeight))
  962.          {
  963.             measuredHeight = height;
  964.          }
  965.       }
  966.       
  967.       private function findNextItemRenderer(param1:Boolean) : Boolean
  968.       {
  969.          if(!lastEditedItemPosition)
  970.          {
  971.             return false;
  972.          }
  973.          if(_proposedEditedItemPosition !== undefined)
  974.          {
  975.             return true;
  976.          }
  977.          _editedItemPosition = lastEditedItemPosition;
  978.          var _loc2_:int = _editedItemPosition.rowIndex;
  979.          var _loc3_:int = _editedItemPosition.columnIndex;
  980.          var _loc4_:int;
  981.          if((_loc4_ = _editedItemPosition.rowIndex + (!!param1 ? -1 : 1)) < collection.length && _loc4_ >= 0)
  982.          {
  983.             _loc2_ = _loc4_;
  984.             var _loc5_:ListEvent;
  985.             (_loc5_ = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true)).rowIndex = _loc2_;
  986.             _loc5_.columnIndex = _loc3_;
  987.             dispatchEvent(_loc5_);
  988.             return true;
  989.          }
  990.          setEditedItemPosition(null);
  991.          losingFocus = true;
  992.          setFocus();
  993.          return false;
  994.       }
  995.       
  996.       override protected function mouseDownHandler(param1:MouseEvent) : void
  997.       {
  998.          var _loc2_:IListItemRenderer = null;
  999.          var _loc3_:Sprite = null;
  1000.          var _loc5_:Point = null;
  1001.          var _loc6_:Boolean = false;
  1002.          _loc2_ = mouseEventToItemRenderer(param1);
  1003.          var _loc4_:Boolean;
  1004.          if(!(_loc4_ = itemRendererContains(itemEditorInstance,DisplayObject(param1.target))))
  1005.          {
  1006.             if(_loc2_ && _loc2_.data)
  1007.             {
  1008.                _loc5_ = itemRendererToIndices(_loc2_);
  1009.                _loc6_ = true;
  1010.                if(itemEditorInstance)
  1011.                {
  1012.                   _loc6_ = endEdit(ListEventReason.NEW_ROW);
  1013.                }
  1014.                if(!_loc6_)
  1015.                {
  1016.                   return;
  1017.                }
  1018.             }
  1019.             else if(itemEditorInstance)
  1020.             {
  1021.                endEdit(ListEventReason.OTHER);
  1022.             }
  1023.             super.mouseDownHandler(param1);
  1024.          }
  1025.       }
  1026.       
  1027.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  1028.       {
  1029.          if(itemEditorInstance)
  1030.          {
  1031.             return;
  1032.          }
  1033.          super.keyDownHandler(param1);
  1034.       }
  1035.       
  1036.       override protected function focusInHandler(param1:FocusEvent) : void
  1037.       {
  1038.          var _loc2_:* = false;
  1039.          if(param1.target != this)
  1040.          {
  1041.             return;
  1042.          }
  1043.          if(losingFocus)
  1044.          {
  1045.             losingFocus = false;
  1046.             return;
  1047.          }
  1048.          super.focusInHandler(param1);
  1049.          if(editable && !mx_internal::isPressed)
  1050.          {
  1051.             _editedItemPosition = lastEditedItemPosition;
  1052.             _loc2_ = editedItemPosition != null;
  1053.             if(!_editedItemPosition)
  1054.             {
  1055.                _editedItemPosition = {
  1056.                   "rowIndex":0,
  1057.                   "columnIndex":0
  1058.                };
  1059.                _loc2_ = Boolean(listItems.length && listItems[0].length > 0);
  1060.             }
  1061.             if(_loc2_)
  1062.             {
  1063.                setEditedItemPosition(_editedItemPosition);
  1064.             }
  1065.          }
  1066.          if(editable)
  1067.          {
  1068.             addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  1069.             addEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  1070.          }
  1071.       }
  1072.       
  1073.       override protected function mouseEventToItemRenderer(param1:MouseEvent) : IListItemRenderer
  1074.       {
  1075.          var _loc2_:IListItemRenderer = super.mouseEventToItemRenderer(param1);
  1076.          return _loc2_ == itemEditorInstance ? null : _loc2_;
  1077.       }
  1078.       
  1079.       protected function makeListData(param1:Object, param2:String, param3:int) : BaseListData
  1080.       {
  1081.          return new ListData(itemToLabel(param1),itemToIcon(param1),labelField,param2,this,param3);
  1082.       }
  1083.       
  1084.       public function createItemEditor(param1:int, param2:int) : void
  1085.       {
  1086.          var _loc5_:Number = NaN;
  1087.          var _loc6_:Number = NaN;
  1088.          var _loc7_:Number = NaN;
  1089.          var _loc8_:Number = NaN;
  1090.          param1 = 0;
  1091.          if(param2 > lockedRowCount)
  1092.          {
  1093.             param2 -= verticalScrollPosition;
  1094.          }
  1095.          var _loc3_:IListItemRenderer = listItems[param2][param1];
  1096.          var _loc4_:ListRowInfo = rowInfo[param2];
  1097.          if(!rendererIsEditor)
  1098.          {
  1099.             _loc5_ = 0;
  1100.             _loc6_ = -2;
  1101.             _loc7_ = 0;
  1102.             _loc8_ = 4;
  1103.             if(!itemEditorInstance)
  1104.             {
  1105.                _loc5_ = editorXOffset;
  1106.                _loc6_ = editorYOffset;
  1107.                _loc7_ = editorWidthOffset;
  1108.                _loc8_ = editorHeightOffset;
  1109.                itemEditorInstance = itemEditor.newInstance();
  1110.                itemEditorInstance.owner = this;
  1111.                itemEditorInstance.styleName = this;
  1112.                listContent.addChild(DisplayObject(itemEditorInstance));
  1113.             }
  1114.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  1115.             itemEditorInstance.visible = true;
  1116.             layoutEditor(_loc3_.x + _loc5_,_loc4_.y + _loc6_,Math.min(_loc3_.width + _loc7_,listContent.width - listContent.x - itemEditorInstance.x),Math.min(_loc4_.height + _loc8_,listContent.height - listContent.y - itemEditorInstance.y));
  1117.             DisplayObject(itemEditorInstance).addEventListener("focusOut",itemEditorFocusOutHandler);
  1118.          }
  1119.          else
  1120.          {
  1121.             itemEditorInstance = _loc3_;
  1122.          }
  1123.          DisplayObject(itemEditorInstance).addEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1124.          stage.addEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true,0,true);
  1125.       }
  1126.       
  1127.       public function get lockedRowCount() : int
  1128.       {
  1129.          return mx_internal::_lockedRowCount;
  1130.       }
  1131.       
  1132.       override public function set enabled(param1:Boolean) : void
  1133.       {
  1134.          super.enabled = param1;
  1135.          if(itemEditorInstance)
  1136.          {
  1137.             endEdit(ListEventReason.OTHER);
  1138.          }
  1139.          invalidateDisplayList();
  1140.       }
  1141.       
  1142.       protected function endEdit(param1:String) : Boolean
  1143.       {
  1144.          if(!editedItemRenderer)
  1145.          {
  1146.             return true;
  1147.          }
  1148.          inEndEdit = true;
  1149.          var _loc2_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_END,false,true);
  1150.          _loc2_.rowIndex = editedItemPosition.rowIndex;
  1151.          _loc2_.itemRenderer = editedItemRenderer;
  1152.          _loc2_.reason = param1;
  1153.          dispatchEvent(_loc2_);
  1154.          dontEdit = itemEditorInstance != null;
  1155.          if(!dontEdit && param1 == ListEventReason.CANCELLED)
  1156.          {
  1157.             losingFocus = true;
  1158.             setFocus();
  1159.          }
  1160.          inEndEdit = false;
  1161.          return !_loc2_.isDefaultPrevented();
  1162.       }
  1163.       
  1164.       override protected function collectionChangeHandler(param1:Event) : void
  1165.       {
  1166.          var _loc2_:CollectionEvent = null;
  1167.          if(param1 is CollectionEvent)
  1168.          {
  1169.             _loc2_ = CollectionEvent(param1);
  1170.             if(_loc2_.kind == CollectionEventKind.REMOVE)
  1171.             {
  1172.                if(editedItemPosition)
  1173.                {
  1174.                   if(collection.length == 0)
  1175.                   {
  1176.                      if(itemEditorInstance)
  1177.                      {
  1178.                         endEdit(ListEventReason.CANCELLED);
  1179.                      }
  1180.                      setEditedItemPosition(null);
  1181.                   }
  1182.                   else if(_loc2_.location <= editedItemPosition.rowIndex)
  1183.                   {
  1184.                      if(inEndEdit)
  1185.                      {
  1186.                         _editedItemPosition = {
  1187.                            "columnIndex":editedItemPosition.columnIndex,
  1188.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1189.                         };
  1190.                      }
  1191.                      else
  1192.                      {
  1193.                         setEditedItemPosition({
  1194.                            "columnIndex":editedItemPosition.columnIndex,
  1195.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1196.                         });
  1197.                      }
  1198.                   }
  1199.                }
  1200.             }
  1201.          }
  1202.          super.collectionChangeHandler(param1);
  1203.       }
  1204.       
  1205.       override public function get baselinePosition() : Number
  1206.       {
  1207.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1208.          {
  1209.             if(listItems.length && listItems[0].length)
  1210.             {
  1211.                return borderMetrics.top + mx_internal::cachedPaddingTop + listItems[0][0].baselinePosition;
  1212.             }
  1213.             return NaN;
  1214.          }
  1215.          return super.baselinePosition;
  1216.       }
  1217.       
  1218.       private function itemEditorFocusOutHandler(param1:FocusEvent) : void
  1219.       {
  1220.          if(param1.relatedObject && contains(param1.relatedObject))
  1221.          {
  1222.             return;
  1223.          }
  1224.          if(!param1.relatedObject)
  1225.          {
  1226.             return;
  1227.          }
  1228.          if(itemEditorInstance)
  1229.          {
  1230.             endEdit(ListEventReason.OTHER);
  1231.          }
  1232.       }
  1233.       
  1234.       override public function set dataProvider(param1:Object) : void
  1235.       {
  1236.          if(itemEditorInstance)
  1237.          {
  1238.             endEdit(ListEventReason.OTHER);
  1239.          }
  1240.          super.dataProvider = param1;
  1241.       }
  1242.       
  1243.       override protected function initializeAccessibility() : void
  1244.       {
  1245.          if(mx_internal::createAccessibilityImplementation != null)
  1246.          {
  1247.             createAccessibilityImplementation(this);
  1248.          }
  1249.       }
  1250.       
  1251.       override protected function configureScrollBars() : void
  1252.       {
  1253.          var _loc2_:Number = NaN;
  1254.          var _loc3_:int = 0;
  1255.          var _loc1_:int = listItems.length;
  1256.          if(_loc1_ == 0)
  1257.          {
  1258.             return;
  1259.          }
  1260.          var _loc4_:int = listItems.length;
  1261.          while(_loc1_ > 1 && rowInfo[_loc4_ - 1].y + rowInfo[_loc4_ - 1].height > listContent.height - listContent.bottomOffset)
  1262.          {
  1263.             _loc1_--;
  1264.             _loc4_--;
  1265.          }
  1266.          var _loc5_:int = verticalScrollPosition - lockedRowCount - 1;
  1267.          var _loc6_:int = 0;
  1268.          while(_loc1_ && listItems[_loc1_ - 1].length == 0)
  1269.          {
  1270.             if(!(collection && _loc1_ + _loc5_ >= collection.length))
  1271.             {
  1272.                break;
  1273.             }
  1274.             _loc1_--;
  1275.             _loc6_++;
  1276.          }
  1277.          if(verticalScrollPosition > 0 && _loc6_ > 0 && !runningDataEffect)
  1278.          {
  1279.             if(adjustVerticalScrollPositionDownward(Math.max(_loc1_,1)))
  1280.             {
  1281.                return;
  1282.             }
  1283.          }
  1284.          if(listContent.topOffset)
  1285.          {
  1286.             _loc2_ = Math.abs(listContent.topOffset);
  1287.             _loc3_ = 0;
  1288.             while(rowInfo[_loc3_].y + rowInfo[_loc3_].height <= _loc2_)
  1289.             {
  1290.                _loc1_--;
  1291.                _loc3_++;
  1292.                if(_loc3_ == _loc1_)
  1293.                {
  1294.                   break;
  1295.                }
  1296.             }
  1297.          }
  1298.          var _loc7_:int = listItems[0].length;
  1299.          var _loc8_:Object = horizontalScrollBar;
  1300.          var _loc9_:Object = verticalScrollBar;
  1301.          var _loc10_:int = Math.round(unscaledWidth);
  1302.          var _loc11_:int = !!collection ? int(collection.length - lockedRowCount) : 0;
  1303.          var _loc12_:int = _loc1_ - lockedRowCount;
  1304.          setScrollBarProperties(!!isNaN(mx_internal::_maxHorizontalScrollPosition) ? int(Math.round(listContent.width)) : int(Math.round(mx_internal::_maxHorizontalScrollPosition + _loc10_)),_loc10_,_loc11_,_loc12_);
  1305.          maxVerticalScrollPosition = Math.max(_loc11_ - _loc12_,0);
  1306.       }
  1307.       
  1308.       override protected function mouseWheelHandler(param1:MouseEvent) : void
  1309.       {
  1310.          if(itemEditorInstance)
  1311.          {
  1312.             endEdit(ListEventReason.OTHER);
  1313.          }
  1314.          super.mouseWheelHandler(param1);
  1315.       }
  1316.       
  1317.       override public function set maxHorizontalScrollPosition(param1:Number) : void
  1318.       {
  1319.          super.maxHorizontalScrollPosition = param1;
  1320.          scrollAreaChanged = true;
  1321.          invalidateDisplayList();
  1322.       }
  1323.       
  1324.       override protected function scrollHandler(param1:Event) : void
  1325.       {
  1326.          var scrollBar:ScrollBar = null;
  1327.          var pos:Number = NaN;
  1328.          var delta:int = 0;
  1329.          var o:EdgeMetrics = null;
  1330.          var bookmark:CursorBookmark = null;
  1331.          var event:Event = param1;
  1332.          if(event is ScrollEvent)
  1333.          {
  1334.             if(itemEditorInstance)
  1335.             {
  1336.                endEdit(ListEventReason.OTHER);
  1337.             }
  1338.             if(!liveScrolling && ScrollEvent(event).detail == ScrollEventDetail.THUMB_TRACK)
  1339.             {
  1340.                return;
  1341.             }
  1342.             scrollBar = ScrollBar(event.target);
  1343.             pos = scrollBar.scrollPosition;
  1344.             removeClipMask();
  1345.             if(scrollBar == verticalScrollBar)
  1346.             {
  1347.                delta = pos - verticalScrollPosition;
  1348.                super.scrollHandler(event);
  1349.                if(Math.abs(delta) >= listItems.length - lockedRowCount || !iteratorValid)
  1350.                {
  1351.                   try
  1352.                   {
  1353.                      if(!iteratorValid)
  1354.                      {
  1355.                         iterator.seek(CursorBookmark.FIRST,pos);
  1356.                      }
  1357.                      else
  1358.                      {
  1359.                         iterator.seek(CursorBookmark.CURRENT,delta);
  1360.                      }
  1361.                      if(!iteratorValid)
  1362.                      {
  1363.                         iteratorValid = true;
  1364.                         lastSeekPending = null;
  1365.                      }
  1366.                   }
  1367.                   catch(e:ItemPendingError)
  1368.                   {
  1369.                      lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,pos);
  1370.                      e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1371.                      iteratorValid = false;
  1372.                   }
  1373.                   bookmark = iterator.bookmark;
  1374.                   clearIndicators();
  1375.                   clearVisibleData();
  1376.                   makeRowsAndColumns(0,0,listContent.width,listContent.height,0,0);
  1377.                   iterator.seek(bookmark,0);
  1378.                }
  1379.                else if(delta != 0)
  1380.                {
  1381.                   scrollVertically(pos,Math.abs(delta),Boolean(delta > 0));
  1382.                }
  1383.                if(variableRowHeight)
  1384.                {
  1385.                   configureScrollBars();
  1386.                }
  1387.                drawRowBackgrounds();
  1388.             }
  1389.             else
  1390.             {
  1391.                delta = pos - mx_internal::_horizontalScrollPosition;
  1392.                super.scrollHandler(event);
  1393.                scrollHorizontally(pos,Math.abs(delta),Boolean(delta > 0));
  1394.             }
  1395.             addClipMask(false);
  1396.          }
  1397.       }
  1398.       
  1399.       public function get editedItemRenderer() : IListItemRenderer
  1400.       {
  1401.          if(!itemEditorInstance)
  1402.          {
  1403.             return null;
  1404.          }
  1405.          return listItems[actualRowIndex][actualColIndex];
  1406.       }
  1407.       
  1408.       private function commitEditedItemPosition(param1:Object) : void
  1409.       {
  1410.          var _loc10_:String = null;
  1411.          if(!enabled || !editable)
  1412.          {
  1413.             return;
  1414.          }
  1415.          if(itemEditorInstance && param1 && itemEditorInstance is IFocusManagerComponent && _editedItemPosition.rowIndex == param1.rowIndex)
  1416.          {
  1417.             IFocusManagerComponent(itemEditorInstance).setFocus();
  1418.             return;
  1419.          }
  1420.          if(itemEditorInstance)
  1421.          {
  1422.             if(!param1)
  1423.             {
  1424.                _loc10_ = ListEventReason.OTHER;
  1425.             }
  1426.             else
  1427.             {
  1428.                _loc10_ = ListEventReason.NEW_ROW;
  1429.             }
  1430.             if(!endEdit(_loc10_) && _loc10_ != ListEventReason.OTHER)
  1431.             {
  1432.                return;
  1433.             }
  1434.          }
  1435.          _editedItemPosition = param1;
  1436.          if(!param1 || dontEdit)
  1437.          {
  1438.             return;
  1439.          }
  1440.          var _loc2_:int = param1.rowIndex;
  1441.          var _loc3_:int = param1.columnIndex;
  1442.          if(selectedIndex != param1.rowIndex)
  1443.          {
  1444.             commitSelectedIndex(param1.rowIndex);
  1445.          }
  1446.          var _loc4_:int = lockedRowCount;
  1447.          var _loc5_:int = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1448.          var _loc6_:int = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1449.          if(_loc2_ > _loc4_)
  1450.          {
  1451.             if(_loc2_ < verticalScrollPosition + _loc4_)
  1452.             {
  1453.                verticalScrollPosition = _loc2_ - _loc4_;
  1454.             }
  1455.             else
  1456.             {
  1457.                while(_loc2_ > _loc5_ || _loc2_ == _loc5_ && _loc2_ > verticalScrollPosition + _loc4_ && _loc6_)
  1458.                {
  1459.                   if(verticalScrollPosition == maxVerticalScrollPosition)
  1460.                   {
  1461.                      break;
  1462.                   }
  1463.                   verticalScrollPosition = Math.min(verticalScrollPosition + (_loc2_ > _loc5_ ? _loc2_ - _loc5_ : _loc6_),maxVerticalScrollPosition);
  1464.                   _loc5_ = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1465.                   _loc6_ = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1466.                }
  1467.             }
  1468.             actualRowIndex = _loc2_ - verticalScrollPosition;
  1469.          }
  1470.          else
  1471.          {
  1472.             if(_loc2_ == _loc4_)
  1473.             {
  1474.                verticalScrollPosition = 0;
  1475.             }
  1476.             actualRowIndex = _loc2_;
  1477.          }
  1478.          var _loc7_:EdgeMetrics = borderMetrics;
  1479.          actualColIndex = _loc3_;
  1480.          var _loc8_:IListItemRenderer;
  1481.          if(!(_loc8_ = listItems[actualRowIndex][actualColIndex]))
  1482.          {
  1483.             commitEditedItemPosition(null);
  1484.             return;
  1485.          }
  1486.          if(!isItemEditable(_loc8_.data))
  1487.          {
  1488.             commitEditedItemPosition(null);
  1489.             return;
  1490.          }
  1491.          var _loc9_:ListEvent;
  1492.          (_loc9_ = new ListEvent(ListEvent.ITEM_EDIT_BEGIN,false,true)).rowIndex = _editedItemPosition.rowIndex;
  1493.          _loc9_.itemRenderer = _loc8_;
  1494.          dispatchEvent(_loc9_);
  1495.          lastEditedItemPosition = _editedItemPosition;
  1496.          if(bEditedItemPositionChanged)
  1497.          {
  1498.             bEditedItemPositionChanged = false;
  1499.             commitEditedItemPosition(_proposedEditedItemPosition);
  1500.             _proposedEditedItemPosition = undefined;
  1501.          }
  1502.          if(!itemEditorInstance)
  1503.          {
  1504.             commitEditedItemPosition(null);
  1505.          }
  1506.       }
  1507.       
  1508.       protected function drawRowBackground(param1:Sprite, param2:int, param3:Number, param4:Number, param5:uint, param6:int) : void
  1509.       {
  1510.          var _loc7_:Shape = null;
  1511.          if(param2 < param1.numChildren)
  1512.          {
  1513.             _loc7_ = Shape(param1.getChildAt(param2));
  1514.          }
  1515.          else
  1516.          {
  1517.             (_loc7_ = new FlexShape()).name = "rowBackground";
  1518.             param1.addChild(_loc7_);
  1519.          }
  1520.          param4 = Math.min(rowInfo[param2].height,listContent.height - rowInfo[param2].y);
  1521.          _loc7_.y = rowInfo[param2].y;
  1522.          var _loc8_:Graphics;
  1523.          (_loc8_ = _loc7_.graphics).clear();
  1524.          _loc8_.beginFill(param5,getStyle("backgroundAlpha"));
  1525.          _loc8_.drawRect(0,0,listContent.width,param4);
  1526.          _loc8_.endFill();
  1527.       }
  1528.       
  1529.       override protected function commitProperties() : void
  1530.       {
  1531.          var _loc1_:Number = NaN;
  1532.          var _loc2_:Number = NaN;
  1533.          var _loc3_:IListItemRenderer = null;
  1534.          var _loc4_:Number = NaN;
  1535.          var _loc5_:int = 0;
  1536.          super.commitProperties();
  1537.          if(itemsNeedMeasurement)
  1538.          {
  1539.             itemsNeedMeasurement = false;
  1540.             if(isNaN(explicitRowHeight))
  1541.             {
  1542.                if(iterator)
  1543.                {
  1544.                   _loc1_ = getStyle("paddingTop");
  1545.                   _loc2_ = getStyle("paddingBottom");
  1546.                   _loc3_ = getMeasuringRenderer(iterator.current);
  1547.                   _loc4_ = 200;
  1548.                   if(listContent.width)
  1549.                   {
  1550.                      _loc4_ = listContent.width;
  1551.                   }
  1552.                   _loc3_.explicitWidth = _loc4_;
  1553.                   setupRendererFromData(_loc3_,iterator.current);
  1554.                   _loc5_ = _loc3_.getExplicitOrMeasuredHeight() + _loc1_ + _loc2_;
  1555.                   setRowHeight(Math.max(_loc5_,20));
  1556.                }
  1557.                else
  1558.                {
  1559.                   setRowHeight(20);
  1560.                }
  1561.             }
  1562.             if(isNaN(explicitColumnWidth))
  1563.             {
  1564.                setColumnWidth(measureWidthOfItems(0,explicitRowCount < 1 ? int(defaultRowCount) : int(explicitRowCount)));
  1565.             }
  1566.          }
  1567.       }
  1568.       
  1569.       mx_internal function getMeasuringRenderer(param1:Object) : IListItemRenderer
  1570.       {
  1571.          var _loc2_:IListItemRenderer = null;
  1572.          if(!measuringObjects)
  1573.          {
  1574.             measuringObjects = new Dictionary(true);
  1575.          }
  1576.          var _loc3_:IFactory = getItemRendererFactory(param1);
  1577.          _loc2_ = measuringObjects[_loc3_];
  1578.          if(!_loc2_)
  1579.          {
  1580.             _loc2_ = createItemRenderer(param1);
  1581.             _loc2_.owner = this;
  1582.             _loc2_.name = "hiddenItem";
  1583.             _loc2_.visible = false;
  1584.             _loc2_.styleName = listContent;
  1585.             listContent.addChild(DisplayObject(_loc2_));
  1586.             measuringObjects[_loc3_] = _loc2_;
  1587.          }
  1588.          return _loc2_;
  1589.       }
  1590.       
  1591.       mx_internal function purgeMeasuringRenderers() : void
  1592.       {
  1593.          var _loc1_:IListItemRenderer = null;
  1594.          for each(_loc1_ in measuringObjects)
  1595.          {
  1596.             if(_loc1_.parent)
  1597.             {
  1598.                _loc1_.parent.removeChild(DisplayObject(_loc1_));
  1599.             }
  1600.          }
  1601.          if(!measuringObjects)
  1602.          {
  1603.             measuringObjects = new Dictionary(true);
  1604.          }
  1605.       }
  1606.       
  1607.       private function adjustVerticalScrollPositionDownward(param1:int) : Boolean
  1608.       {
  1609.          var n:int = 0;
  1610.          var j:int = 0;
  1611.          var more:Boolean = false;
  1612.          var data:Object = null;
  1613.          var rowCount:int = param1;
  1614.          var bookmark:CursorBookmark = iterator.bookmark;
  1615.          var h:Number = 0;
  1616.          var ch:Number = 0;
  1617.          var paddingTop:Number = getStyle("paddingTop");
  1618.          var paddingBottom:Number = getStyle("paddingBottom");
  1619.          var paddingLeft:Number = getStyle("paddingLeft");
  1620.          var paddingRight:Number = getStyle("paddingRight");
  1621.          h = rowInfo[rowCount - 1].y + rowInfo[rowCount - 1].height;
  1622.          h = listContent.heightExcludingOffsets - listContent.topOffset - h;
  1623.          var numRows:int = 0;
  1624.          try
  1625.          {
  1626.             if(iterator.afterLast)
  1627.             {
  1628.                iterator.seek(CursorBookmark.LAST,0);
  1629.             }
  1630.             else
  1631.             {
  1632.                more = iterator.movePrevious();
  1633.             }
  1634.          }
  1635.          catch(e:ItemPendingError)
  1636.          {
  1637.             more = false;
  1638.          }
  1639.          if(!more)
  1640.          {
  1641.             super.verticalScrollPosition = 0;
  1642.             try
  1643.             {
  1644.                iterator.seek(CursorBookmark.FIRST,0);
  1645.                if(!iteratorValid)
  1646.                {
  1647.                   iteratorValid = true;
  1648.                   lastSeekPending = null;
  1649.                }
  1650.             }
  1651.             catch(e:ItemPendingError)
  1652.             {
  1653.                lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,0);
  1654.                e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1655.                iteratorValid = false;
  1656.                invalidateList();
  1657.                return true;
  1658.             }
  1659.             updateList();
  1660.             return true;
  1661.          }
  1662.          var item:IListItemRenderer = getMeasuringRenderer(iterator.current);
  1663.          item.explicitWidth = listContent.width - paddingLeft - paddingRight;
  1664.          while(h > 0 && more)
  1665.          {
  1666.             if(more)
  1667.             {
  1668.                data = iterator.current;
  1669.                setupRendererFromData(item,data);
  1670.                ch = !!variableRowHeight ? Number(item.getExplicitOrMeasuredHeight() + paddingBottom + paddingTop) : Number(rowHeight);
  1671.             }
  1672.             h -= ch;
  1673.             try
  1674.             {
  1675.                more = iterator.movePrevious();
  1676.                numRows++;
  1677.             }
  1678.             catch(e:ItemPendingError)
  1679.             {
  1680.                more = false;
  1681.             }
  1682.          }
  1683.          if(h < 0)
  1684.          {
  1685.             numRows--;
  1686.          }
  1687.          iterator.seek(bookmark,0);
  1688.          verticalScrollPosition = Math.max(0,verticalScrollPosition - numRows);
  1689.          if(numRows > 0 && !variableRowHeight)
  1690.          {
  1691.             configureScrollBars();
  1692.          }
  1693.          return numRows > 0;
  1694.       }
  1695.       
  1696.       public function isItemEditable(param1:Object) : Boolean
  1697.       {
  1698.          if(!editable)
  1699.          {
  1700.             return false;
  1701.          }
  1702.          if(param1 == null)
  1703.          {
  1704.             return false;
  1705.          }
  1706.          return true;
  1707.       }
  1708.       
  1709.       override protected function adjustListContent(param1:Number = -1, param2:Number = -1) : void
  1710.       {
  1711.          var _loc3_:Number = viewMetrics.left + Math.max(listContent.leftOffset,0);
  1712.          var _loc4_:Number = viewMetrics.top + listContent.topOffset;
  1713.          listContent.move(_loc3_,_loc4_);
  1714.          var _loc5_:Number = Math.max(0,listContent.rightOffset) - _loc3_ - viewMetrics.right;
  1715.          var _loc6_:Number = Math.max(0,listContent.bottomOffset) - _loc4_ - viewMetrics.bottom;
  1716.          var _loc7_:Number = param1 + _loc5_;
  1717.          if(horizontalScrollPolicy == ScrollPolicy.ON || horizontalScrollPolicy == ScrollPolicy.AUTO && !isNaN(mx_internal::_maxHorizontalScrollPosition))
  1718.          {
  1719.             if(isNaN(mx_internal::_maxHorizontalScrollPosition))
  1720.             {
  1721.                _loc7_ *= 2;
  1722.             }
  1723.             else
  1724.             {
  1725.                _loc7_ += mx_internal::_maxHorizontalScrollPosition;
  1726.             }
  1727.          }
  1728.          listContent.setActualSize(_loc7_,param2 + _loc6_);
  1729.       }
  1730.       
  1731.       private function editorMouseDownHandler(param1:MouseEvent) : void
  1732.       {
  1733.          if(!itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  1734.          {
  1735.             endEdit(ListEventReason.OTHER);
  1736.          }
  1737.       }
  1738.       
  1739.       override public function set itemRenderer(param1:IFactory) : void
  1740.       {
  1741.          super.itemRenderer = param1;
  1742.          purgeMeasuringRenderers();
  1743.       }
  1744.       
  1745.       mx_internal function setupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  1746.       {
  1747.          var _loc3_:Object = param2 is ItemWrapper ? param2.data : param2;
  1748.          if(param1 is IDropInListItemRenderer)
  1749.          {
  1750.             if(_loc3_ != null)
  1751.             {
  1752.                IDropInListItemRenderer(param1).listData = makeListData(_loc3_,itemToUID(param2),0);
  1753.             }
  1754.             else
  1755.             {
  1756.                IDropInListItemRenderer(param1).listData = null;
  1757.             }
  1758.          }
  1759.          param1.data = _loc3_;
  1760.          if(param1 is IInvalidating)
  1761.          {
  1762.             IInvalidating(param1).invalidateSize();
  1763.          }
  1764.          UIComponentGlobals.layoutManager.validateClient(param1,true);
  1765.       }
  1766.       
  1767.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1768.       {
  1769.          super.updateDisplayList(param1,param2);
  1770.          setRowCount(listItems.length);
  1771.          if(bEditedItemPositionChanged && !editingTemporarilyPrevented(_proposedEditedItemPosition))
  1772.          {
  1773.             bEditedItemPositionChanged = false;
  1774.             commitEditedItemPosition(_proposedEditedItemPosition);
  1775.             _proposedEditedItemPosition = undefined;
  1776.          }
  1777.          drawRowBackgrounds();
  1778.       }
  1779.       
  1780.       public function destroyItemEditor() : void
  1781.       {
  1782.          var _loc1_:ListEvent = null;
  1783.          if(itemEditorInstance)
  1784.          {
  1785.             DisplayObject(itemEditorInstance).removeEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1786.             if(stage)
  1787.             {
  1788.                stage.removeEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true);
  1789.             }
  1790.             _loc1_ = new ListEvent(ListEvent.ITEM_FOCUS_OUT);
  1791.             _loc1_.rowIndex = _editedItemPosition.rowIndex;
  1792.             _loc1_.itemRenderer = editedItemRenderer;
  1793.             dispatchEvent(_loc1_);
  1794.             if(!rendererIsEditor)
  1795.             {
  1796.                if(itemEditorInstance && itemEditorInstance is UIComponent)
  1797.                {
  1798.                   UIComponent(itemEditorInstance).drawFocus(false);
  1799.                }
  1800.                listContent.removeChild(DisplayObject(itemEditorInstance));
  1801.             }
  1802.             itemEditorInstance = null;
  1803.             _editedItemPosition = null;
  1804.          }
  1805.       }
  1806.       
  1807.       mx_internal function callMakeListData(param1:Object, param2:String, param3:int) : BaseListData
  1808.       {
  1809.          return makeListData(param1,param2,param3);
  1810.       }
  1811.       
  1812.       public function set lockedRowCount(param1:int) : void
  1813.       {
  1814.          _lockedRowCount = param1;
  1815.          invalidateDisplayList();
  1816.       }
  1817.    }
  1818. }
  1819.